const express = require('express');
const router = express.Router();
const { Interaction, AIRole } = require('../models');
const { authenticateToken, isAdmin } = require('../middleware/auth');
const callAIProvider = require('../services/aiProvider');

// 创建交互记录
router.post('/', authenticateToken, async (req, res) => {
  try {
    const { ai_role_id, input, type = 'text' } = req.body;
    const user_id = req.user.id;
    
    // 查找AI角色，获取系统提示词
    const aiRole = await AIRole.findByPk(ai_role_id);
    if (!aiRole) {
      return res.status(404).json({ error: 'AI角色不存在' });
    }
    
    // 调用第三方AI API获取响应，传入系统提示词和AI角色配置
    let response = await callAIProvider(ai_role_id, input, type, aiRole.system_prompt, aiRole);
    
    // 创建交互记录
    const newInteraction = await Interaction.create({
      user_id,
      ai_role_id,
      input,
      response: typeof response === 'object' ? JSON.stringify(response) : response,
      type
    });
    
    res.json({ response });
  } catch (error) {
    console.error('交互失败:', error);
    res.status(500).json({ error: '交互失败', message: error.message });
  }
});

// 获取用户的交互历史
router.get('/', authenticateToken, async (req, res) => {
  try {
    const interactions = await Interaction.findAll({
      where: { user_id: req.user.id },
      include: [
        {
          model: AIRole,
          attributes: ['name', 'avatar']
        }
      ],
      order: [['created_at', 'DESC']]
    });
    
    // 处理响应数据，如果存储的是JSON字符串，则解析为对象
    const processedInteractions = interactions.map(interaction => {
      const item = interaction.toJSON();
      if (typeof item.response === 'string' && (item.response.startsWith('{') || item.response.startsWith('['))) {
        try {
          item.response = JSON.parse(item.response);
        } catch (e) {
          // 如果解析失败，保持原样
        }
      }
      return item;
    });
    
    res.json(processedInteractions);
  } catch (error) {
    console.error('获取交互历史失败:', error);
    res.status(500).json({ error: '获取交互历史失败' });
  }
});

// 管理员在线测试接口
router.post('/test', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { ai_role_id, input, type = 'text', model_override } = req.body;
    
    // 查找AI角色，获取系统提示词
    const aiRole = await AIRole.findByPk(ai_role_id);
    if (!aiRole) {
      return res.status(404).json({ error: 'AI角色不存在' });
    }
    
    // 从API配置中获取实际模型名称
    let modelName = '未设置';
    let originalModel = null;
    
    try {
      if (aiRole.api_config && typeof aiRole.api_config === 'object') {
        originalModel = aiRole.api_config.model;
        modelName = originalModel || '未设置';
        
        // 如果指定了模型覆盖，则临时修改配置
        if (model_override) {
          // 创建配置副本，避免修改原始数据
          aiRole.api_config = {...aiRole.api_config, model: model_override};
          modelName = model_override;
        }
      } else if (typeof aiRole.api_config === 'string') {
        // 如果存储为字符串，尝试解析
        const configObj = JSON.parse(aiRole.api_config);
        originalModel = configObj.model;
        modelName = originalModel || '未设置';
        
        // 如果指定了模型覆盖，则临时修改配置
        if (model_override) {
          const newConfig = {...configObj, model: model_override};
          aiRole.api_config = newConfig;
          modelName = model_override;
        }
      }
    } catch (e) {
      console.warn('无法解析API配置', e);
    }
    
    // 记录测试信息，包括是否覆盖了模型
    if (model_override) {
      console.log(`管理员正在测试调用AI角色: ${aiRole.name} (ID: ${ai_role_id}), 提供商: ${aiRole.api_provider}, 模型: ${modelName} (已覆盖默认模型: ${originalModel})`);
    } else {
      console.log(`管理员正在测试调用AI角色: ${aiRole.name} (ID: ${ai_role_id}), 提供商: ${aiRole.api_provider}, 模型: ${modelName}`);
    }
    
    // 调用第三方AI API获取响应，传入系统提示词和AI角色配置
    let response = await callAIProvider(ai_role_id, input, type, aiRole.system_prompt, aiRole);
    
    // 这里不创建交互记录，只返回响应结果
    res.json({ 
      success: true,
      response,
      metadata: {
        provider: aiRole.api_provider,
        model: modelName,
        model_override: model_override ? true : false,
        timestamp: new Date().toISOString()
      }
    });
  } catch (error) {
    console.error('管理员测试AI调用失败:', error);
    res.status(500).json({ 
      success: false, 
      error: '测试调用失败', 
      message: error.message,
      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
    });
  }
});

module.exports = router;  